-- Funções que operam sobre a tabela de símbolos

module Heap
(
	search,
	getValue
) where

import Tokens
import Types


-- Tabela de arrays, Nome, Tamanho, Escopo
searchA :: ArraysT -> String -> Escopo -> Bool
searchA at nome esc =
	case at of
		[] -> False
		(a, b, c, d):e -> if (a == nome) && (d == esc) then
									True
								else
									searchA at nome esc

--
searchT :: UserTypesD -> String -> Escopo -> Bool
searchT table name esc =
	case table of
		[] -> False
		(a:b:c):d -> if (a == name) && (c == esc) then
							True
						 else
						 	searchT d name esc
						 	

-- Verifica se determinado nome de variavel pertence ao escopo determinado
-- tabela_simbolos nome escopo
searchS :: SymbolsT -> String -> Escopo -> Bool
searchS symbolsT name esc =
	case symbolsT of
		[] -> False
		(a, b, c):x ->	if ((a == name) || (a == name++"/const")) && (c == esc) then
								True
							else
								searchS x name esc
								
-- Retorna a lista de campos que compõem o tipo definido
-- Nome do tipo, tabela de tipos definidos
getTypeComp :: String -> Escopo -> UserTypesD -> (Bool, [Token])
getTypeComp tnome esc table =	
	case table of
		[] -> (False, [])
		(a, b, c):d -> if (a == tnome) && (c == esc) then
								(True, b)
							else
								getTypeComp nome esc table

-- Recupera o valor armazenado pela variável determinada
-- tabela_simbolos nome escopo
getValueS :: SymbolsT -> String -> Escopo -> Token
getValueS symbolsT name esc =
	case symbolsT of
		[] -> Error_tk
		(a, b, c):x ->	if a == name && c == esc then
								case b of
									[] -> Error_v -- ????
									y:z -> tokenToValue y -- Retorna o Value correspondente(?)
							else
								getValueS x name esc
								
									
getTypeT :: UserTypeD -> String -> Escopo -> (Bool, [Utype])
getTypeT symbolsT nome esc =
	case symbolsT of
		[] -> (False, [])
		(a, b, c):d -> if (a == nome) && (c == esc) then
								(True, b)
							else
								getTypeT d nome esc

-- Retorna o tipo da variável determinada
-- tabela_simbolos nome escopo
getTypeS :: SymbolsT -> String -> Escopo -> Type
getTypeS symbolsT name esc =
	case symbolsT of
		[] -> Error_t
		(a, b, c):x ->	if a == name && c == esc then
								case b of
									[] -> Error_t
									y:z -> tokenToType y
							else
								getTypeS x name esc
								
								
-- Insere variavel na tabela
-- tabela_simbolos nome escopo variável
insertS :: SymbolsT -> String -> Escopo -> Var -> (Bool, SymbolsT)
insertS symbolsT name esc var =
	let f = (searchS symbolsT name esc) in
	if f then
		(True, var:symbolsT)
	else
		(False, symbolsT)

-- Insere array na tabela
-- tabela de arrays, tabela de simbolos, nome escopo
insertA :: ArraysT -> SymbolsT -> String -> Array -> Escopo -> (Bool, ArraysT, SymbolsT)
insertA nome at st arr esc =
	let f = searchA at nome esc in
	if f then
		(True, arr:at, )

-- Remove a variável especificada da tabela
-- tabela_simbolos nome escopo
removeS :: SymbolsT -> String -> String -> SymbolsT
removeS symbolsT name esc =
	case symbolsT of
		[] -> []
		((a, b, c):x) ->	if a == name && c == esc then
									x
								else
									removeS x name esc
